/* lkmain.c */

/*
 *  Copyright (C) 1989-2025  Alan R. Baldwin
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *
 * Alan R. Baldwin
 * 721 Berkeley St.
 * Kent, Ohio  44240
 */

#include "aslink.h"

/*)Module	lkmain.c
 *
 *	The module lkmain.c contains the functions which
 *	(1) input the linker options, parameters, and specifications
 *	(2) perform a two pass link
 *	(3) produce the appropriate linked data output and/or
 *	    link map file and/or relocated listing files.
 *
 *	lkmain.c contains the following functions:
 *		FILE *	afile()
 *		void	bassav()
 *		void	gblsav()
 *		int	intsiz()
 *              void    link_main()
 *		void	lkexit()
 *		int	fndext()
 *		int	fndidx()
 *		int	main()
 *		void	map()
 *		int	parse()
 *		void	doparse()
 *		void	setgbl()
 *		void	usage()
 *
 *	lkmain.c contains the following local variables:
 *		char *	usetext[]	array of pointers to the
 *					command option text lines
 *
 */

/* sdld 8051 specific */
/*JCF:  Creates some of the default areas so they are allocated in the right order.*/
void Areas51 (void)
{
        char * rel[] = {
                "XH",
                "H C areas 0 global symbols",
                "A _CODE size 0 flags 0",       /*Each .rel has one, so...*/
                "A REG_BANK_0 size 0 flags 4",  /*Register banks are overlayable*/
                "A REG_BANK_1 size 0 flags 4",
                "A REG_BANK_2 size 0 flags 4",
                "A REG_BANK_3 size 0 flags 4",
                "A BSEG size 0 flags 80",       /*BSEG must be just before BITS*/
                "A BSEG_BYTES size 0 flags 0",  /*Size will be obtained from BSEG in lnkarea()*/
                "A BIT_BANK size 0 flags 4",    /*Bit register bank is overlayable*/
                "A DSEG size 0 flags 0",
                "A OSEG size 0 flags 4",
                "A ISEG size 0 flags 0",
                "A SSEG size 0 flags 4",
                ""
        };
        int j;
        struct sym * sp;

        for (j = 0; rel[j][0] != 0; j++) {
                ip = rel[j];
                link_main();
	}

        /*Set the start address of the default areas:*/
        for (ap = areap; ap; ap = ap->a_ap) {
                /**/ if (!strcmp(ap->a_id, "REG_BANK_0")) { ap->a_addr = 0x00; ap->a_bset = 1; }
                else if (!strcmp(ap->a_id, "REG_BANK_1")) { ap->a_addr = 0x08; ap->a_bset = 1; }
                else if (!strcmp(ap->a_id, "REG_BANK_2")) { ap->a_addr = 0x10; ap->a_bset = 1; }
                else if (!strcmp(ap->a_id, "REG_BANK_3")) { ap->a_addr = 0x18; ap->a_bset = 1; }
                else if (!strcmp(ap->a_id, "BSEG_BYTES")) { ap->a_addr = 0x20; ap->a_bset = 1; }
                else if (TARGET_IS_8051 && !strcmp(ap->a_id, "SSEG")) {
                        if (stacksize) ap->a_axp->a_size = stacksize;
		}
	}

        sp = lkpsym("l_IRAM", 1);
        sp->s_addr = ((iram_size>0) && (iram_size<=0x100)) ? iram_size : 0x0100;
        sp->s_axp = NULL;
        sp->s_type |= S_DEF;
}
/* end sdld 8051 specific */

/*)Function	int	main(argc, argv)
 *
 *		int	argc		number of command line arguments + 1
 *		char *	argv[]		array of pointers to the command line
 *					arguments
 *
 *	The function main() evaluates the command line arguments to
 *	determine if the linker parameters are to input through 'stdin'
 *	or read from a command file.  The functiond nxtline() and parse()
 *	are to input and evaluate the linker parameters.  The linking process
 *	proceeds by making the first pass through each .rel file in the order
 *      presented to the linker.  At the end of the first pass the setarea(),
 *	lnkarea(), setgbl(), and symdef() functions are called to evaluate
 *	the base address terms, link all areas, define global variables,
 *	and look for undefined symbols.  Following these routines a linker
 *	map file may be produced and the linker output files may be opened.
 *	The second pass through the .rel files will output the linked data
 *	in one of the supported formats.
 *
 *	local variables:
 *		int	c		character from argument string
 *		int	i		loop counter
 *		int	j		loop counter
 *		int	k		loop counter
 *
 *	global variables:
 *				 	text line in ib[]
 *		lfile	*cfp		The pointer *cfp points to the
 *				 	current lfile structure
 *		char	ctype[]		array of character types, one per
 *				 	ASCII character
 *		lfile	*filep	 	The pointer *filep points to the
 *				 	beginning of a linked list of
 *				 	lfile structures.
 *		head	*hp		Pointer to the current
 *				 	head structure
 *		char	ib[NINPUT]	.rel file text line
 *		char	*ip		pointer into the .rel file
 *		lfile	*linkp		pointer to first lfile structure
 *				 	containing an input .rel file
 *				 	specification
 *		int	lkerr		error flag
 *		int	oflag		Output file type flag
 *		int	objflg		Linked file/library output object flag
 *		int	pass		linker pass number
 *		int	pflag		print linker command file flag
 *		int	radix		current number conversion radix
 *		FILE	*sfp		The file handle sfp points to the
 *				 	currently open file
 *		lfile	*startp		aslink startup file structure
 *		FILE *	stdout		c_library
 *
 *	functions called:
 *		void	chkbank()	lkbank.c
 *		int	fclose()	c_library
 *		int	fprintf()	c_library
 *		void	library()	lklibr.c
 *		void	link_main()	lkmain.c
 *		void	lkexit()	lkmain.c
 *		void	lkfopen()	lkbank.c
 *		void	lnkarea()	lkarea.c
 *		void	map()		lkmain.c
 *		void	new()		lksym.c
 *		int	nxtline()	lklex.c
 *		int	parse()		lkmain.c
 *		void	reloc()		lkreloc.c
 *		void	search()	lklibr.c
 *		void	setarea()	lkarea.c
 *		void	setbank()	lkbank.c
 *		void	setgbl()	lkmain.c
 *		char *	sprintf()	c_library
 *		void	symdef()	lksym.c
 *		void	usage()		lkmain.c
 *		int	fndidx()	lkmain.c
 *
 *	side effects:
 *		Completion of main() completes the linking process
 *		and may produce a map file (.map) and/or a linked
 *		data files (.ihx or .s19) and/or one or more
 *		relocated listing files (.rst).
 */

int
main(int argc, char *argv[])
{
	int c, i, j, k;

	if (intsiz() < 4) {
		fprintf(stderr, "?ASlink-Error-Size of INT32 is not 32 bits or larger.\n\n");
		exit(ER_FATAL);
	}

        /* sdas specific */
        /* sdas initialization */
        sdld_init(argv[0]);

        /* use these defaults for parsing the .lnk script */
        a_bytes = 4;
        a_mask = 0xFFFFFFFF;
        s_mask = 0x80000000;
        v_mask = 0x7FFFFFFF;
        /* end sdas specific */

        if (!is_sdld())
                fprintf(stdout, "\n");

	startp = (struct lfile *) new (sizeof (struct lfile));
	startp->f_idp = "";

	pflag = 1;

	for(i=1; i<argc; i++) {
		ip = ib;
		if(argv[i][0] == '-') {
			j = i;
			k = 1;
			while((c = argv[j][k]) != '\0') {
				ip = ib;
				sprintf(ip, "-%c", c);
				switch(c) {

				/*
				 * Options with arguments
				 */
				case 'b':
				case 'B':

				case 'g':
				case 'G':

				case 'k':
				case 'K':

				case 'l':
				case 'L':

				case 'f':
				case 'F':

				case 'I':
				case 'X':
				case 'C':
				case 'S':
					strcat(ip, " ");
                                        if (i < argc - 1)
                                                strcat(ip, argv[++i]);
					else
                                                strcpy(ip, "");
					break;
				/*
				 * Preprocess these commands
				 */
				case 'n':
				case 'N':
					pflag = 0;
					break;

				case 'p':
				case 'P':
					pflag = 1;
					break;

				/*
				 * Options without arguments
				 */
				default:
					break;
				}
				if(pflag)
					fprintf(stdout, "ASlink >> %s\n", ip);
				parse();
				k++;
			}
		} else {
			strcpy(ip, argv[i]);
			if(pflag)
				fprintf(stdout, "ASlink >> %s\n", ip);
			parse();
		}
	}

	if (linkp == NULL) {
                usage(ER_FATAL);
	}
	/*
	 * If no input file is specified
	 * then assume a single file with
	 * the same name as the output file.
	 */
	if (lfp == linkp) {
		lfp->f_flp = (struct lfile *) new (sizeof (struct lfile));
		lfp = lfp->f_flp;
		lfp->f_idp = strsto(linkp->f_idp);
		lfp->f_idx = fndidx(linkp->f_idp);
		lfp->f_obj = objflg;
		lfp->f_type = F_REL;
	}

	syminit();

#if SDCDB
	/*
	 * Open SDCC Debug output file
	 */
	SDCDBfopen();
#endif

	for (pass=0; pass<2; ++pass) {
		cfp = NULL;
		sfp = NULL;
		filep = linkp->f_flp;
		hp = NULL;
		radix = 10;

                /* sdld specific */
                if (TARGET_IS_8051)
                        Areas51(); /*JCF: Create the default 8051 areas in the right order*/
                /* end sdld specific */

		while (nxtline()) {
			ip = ib;
                        link_main();
		}
		if (pass == 0) {
			/*
			 * Search libraries for global symbols
			 */
			search();

                        /* sdas specific */
                        /* use these defaults for parsing the .lk script */
                        a_bytes = 4;
			a_mask = 0xFFFFFFFF;
			s_mask = 0x80000000;
			v_mask = 0x7FFFFFFF;
                        /* end sdas specific */

			/*
			 * Set area base addresses.
			 */
			setarea();
			/*
			 * Set bank base addresses.
			 */
			setbank();
			/*
			 * Link all area addresses.
			 */
                        /* sdld 8051 specific */
                        if (is_sdld_target_8051_like())
                                lnkarea2();
                        else
                                /* end sdld 8051 specific */
                                lnkarea();
			/*
			 * Check bank size limits.
			 */
			chkbank(stderr);
			/*
			 * Process global definitions.
			 */
			setgbl();
			/*
			 * Check for undefined globals.
			 */
			symdef(stderr);
#if NOICE
			/*
			 * Open NoICE output file
			 */
			NoICEfopen();
#endif
			/*
			 * Output Link Map.
			 */
			map();

                        /* sdld specific */
                        if (sflag) {    /*JCF: memory usage summary output*/
                                if (is_sdld_target_8051_like()) {
                                        if (summary2(areap)) {
                                                lkexit(1);
					}
				}
                                else {
                                        if (summary(areap)) {
                                                lkexit(1);
					}
				}
			}

                        if ((iram_size) && (!is_sdld_target_8051_like()))
                                iramcheck();

                        /* end sdld specific */

			/*
			 * Open output file(s)
			 */
			lkfopen();
		} else {
			/*
			 * Link in library files
			 */
			library();
			/*
			 * Complete Processing
			 */
			reloc('E');
		}
	}

        if (TARGET_IS_PDK && get_sdld_target() != TARGET_ID_PDK) {
                unsigned ram = 0;
                unsigned rom = 0;
                for (struct area *it = areap; it; it = it->a_ap) {
                        if (!strcmp(it->a_id, "DATA") ||
                            !strcmp(it->a_id, "OSEG")) {
                                if (it->a_addr + it->a_size > ram) {
                                        ram = it->a_addr + it->a_size;
				}
                        } else if (!strcmp(it->a_id, "CODE") ||
                                   !strcmp(it->a_id, "CONST")) {
                                if (it->a_addr + it->a_size > rom) {
                                        rom = it->a_addr + it->a_size;
				}
			}
		}

                enum sdld_target_e target = get_sdld_target();
                const unsigned max_ram =
                    target == TARGET_ID_PDK13 ? 64 :
                    target == TARGET_ID_PDK14 ? 128 : 256;
                const unsigned max_rom =
                    target == TARGET_ID_PDK13 ? 2048 :
                    target == TARGET_ID_PDK14 ? 4096 : 8192;
                if (ram > max_ram) {
                        fprintf(stderr,
                                "?ASlink-Warning-"
                                "RAM value %u too large "
                                "(%uB max)\n", ram, max_ram);
		}
                if (rom > max_rom) {
                        fprintf(stderr,
                                "?ASlink-Warning-"
                                "ROM value %u too large "
                                "(%uW max)\n", rom / 2, max_rom / 2);
		}
	}
        if (TARGET_IS_8051) {
                //JCF:
                CreateAOMF51();
	}

	lkexit(lkerr ? ER_ERROR : ER_NONE);
	return(0);
}

/*)Function	int	intsiz(void)
 *
 *	The function intsiz() returns the size of INT32
 *
 *	local variables:
 *		none
 *
 *	global variables:
 *		none
 *
 *	functions called:
 *		none
 *
 *	side effects:
 *		none
 */

int
intsiz(void)
{
	return(sizeof(a_uint));
}

/*)Function	void	lkexit(i)
 *
 *			int	i	exit code
 *
 *	The function lkexit() explicitly closes all open
 *	files and then terminates the program.
 *
 *	local variables:
 *		none
 *
 *	global variables:
 *		FILE *	jfp		file handle for .noi
 *		FILE *	mfp		file handle for .map
 *		FILE *	rfp		file hanlde for .rst
 *              FILE *  sfp             file handle for .rel
 *		FILE *	tfp		file handle for .lst
 *		FILE *	yfp		file handle for .cdb
 *
 *	functions called:
 *		int	fclose()	c_library
 *		void	exit()		c_library
 *		void	lkfclose()	lkbank.c
 *
 *	side effects:
 *		All files closed. Program terminates.
 */

void
lkexit(int i)
{
	lkfclose();
#if NOICE
	if (jfp != NULL) fclose(jfp);
#endif
	if (mfp != NULL) fclose(mfp);
	if (rfp != NULL) fclose(rfp);
	if (sfp != NULL) { if (sfp != stdin) fclose(sfp); }
	if (tfp != NULL) fclose(tfp);
#if SDCDB
	if (yfp != NULL) fclose(yfp);
#endif
	exit(i);
}

/*)Function     link_main(void)   beware sdld changed name
 *
 *      The function link_main() evaluates the directives for each line of
 *	text read from the .rel file(s).  The valid directives processed
 *	are:
 *              X, D, Q, H, M, A, S, T, R, and P.
 *
 *	local variables:
 *		int	c		first non blank character of a line
 *
 *	global variables:
 *		head	*headp		The pointer to the first
 *				 	head structure of a linked list
 *		head	*hp		Pointer to the current
 *				 	head structure
 *		int	a_bytes		T Line address bytes
 *		int	hilo		Byte ordering
 *		int	pass		linker pass number
 *		int	radix		current number conversion radix
 *
 *	functions called:
 *              char    endline()       lklex.c
 *		void	module()	lkhead.c
 *		void	newarea()	lkarea.c
 *		void	newhead()	lkhead.c
 *		sym *	newsym()	lksym.c
 *		void	NoICEmagic()	lknoice.c
 *		void	reloc()		lkreloc.c
 *
 *	side effects:
 *		Head, area, and symbol structures are created and
 *		the radix is set as the .rel file(s) are read.
 */

void
link_main(void)  /* beware sdld changed name */
{
        char c;

        if ((c=endline()) == 0) { return; }
	switch (c) {

        /* sdld specific */
        case 'O': /* For some important sdcc options */
                if (is_sdld() && pass == 0) {
                        if (NULL == optsdcc) {
                                optsdcc = strsto(&ip[1]);
                                optsdcc_module = hp->m_id;
			}
                        else {
                                if (strcmp(optsdcc, &ip[1]) != 0) {
					fprintf(stderr,
                                                "?ASlink-Warning-Conflicting sdcc options:\n"
                                                "   \"%s\" in module \"%s\" and\n"
                                                "   \"%s\" in module \"%s\".\n",
                                                optsdcc, optsdcc_module, &ip[1], hp->m_id);
					lkerr++;
				}
			}
		}
		break;
        /* end sdld specific */

	case 'X':
	case 'D':
	case 'Q':
		ASxxxx_VERSION = 3;
                a_bytes = 2;    /* use default if unspecified */
                hilo = 0;       /* use default if unspecified */
		if (c == 'X') { radix = 16; } else
		if (c == 'D') { radix = 10; } else
		if (c == 'Q') { radix = 8;  }

		while ((c = get()) != 0) {
			switch(c) {
			case 'H':
				hilo = 1;
				break;

			case 'L':
				hilo = 0;
				break;

			case '2':
				a_bytes = 2;
				break;

			case '3':
				a_bytes = 3;
				break;

			case '4':
				a_bytes = 4;
				break;

			default:
				break;
			}
		}
#ifdef	LONGINT
		switch(a_bytes) {
		default:
			a_bytes = 2;
		case 2:
			a_mask = 0x0000FFFFl;
			s_mask = 0x00008000l;
			v_mask = 0x00007FFFl;
			break;

		case 3:
			a_mask = 0x00FFFFFFl;
			s_mask = 0x00800000l;
			v_mask = 0x007FFFFFl;
			break;

		case 4:
			a_mask = 0xFFFFFFFFl;
			s_mask = 0x80000000l;
			v_mask = 0x7FFFFFFFl;
			break;
		}
#else
		switch(a_bytes) {
		default:
			a_bytes = 2;
		case 2:
			a_mask = 0x0000FFFF;
			s_mask = 0x00008000;
			v_mask = 0x00007FFF;
			break;

		case 3:
			a_mask = 0x00FFFFFF;
			s_mask = 0x00800000;
			v_mask = 0x007FFFFF;
			break;

		case 4:
			a_mask = 0xFFFFFFFF;
			s_mask = 0x80000000;
			v_mask = 0x7FFFFFFF;
			break;
		}
#endif
		break;

	case 'H':
		if (pass == 0) {
			newhead();
		} else {
			if (hp == 0) {
				hp = headp;
			} else {
				hp = hp->h_hp;
			}
		}
		sdp.s_area = NULL;
		sdp.s_areax = NULL;
		sdp.s_addr = 0;
		break;

	case 'M':
		if (pass == 0)
			module();
		break;

	case 'A':
		if (pass == 0)
			newarea();
		if (sdp.s_area == NULL) {
			sdp.s_area = areap;
			sdp.s_areax = areap->a_axp;
			sdp.s_addr = 0;
		}
		break;

	case 'S':
		if (pass == 0)
			newsym();
		break;

	case 'T':
	case 'R':
	case 'P':
		if (pass == 0)
			break;
		reloc(c);
		break;

#if NOICE
	case ';':
		unget(c);
		NoICEmagic();
		break;
#endif

	default:
		break;
	}
}

/*)Function	void	map(void)
 *
 *	The function map() opens the output map file and calls the various
 *	routines to
 *	(1) output the variables in each area,
 *	(2) list the files processed with module names,
 *	(3) list the libraries file processed,
 *	(4) list base address definitions,
 *	(5) list global variable definitions, and
 *	(6) list any undefined variables.
 *
 *	local variables:
 *		int 	i		counter
 *		head *	hdp		pointer to head structure
 *		lbfile *lbfh		pointer to library file structure
 *
 *	global variables:
 *		area	*ap		Pointer to the current
 *				 	area structure
 *		area	*areap		The pointer to the first
 *				 	area structure of a linked list
 *		base	*basep		The pointer to the first
 *				 	base structure
 *		base	*bsp		Pointer to the current
 *				 	base structure
 *		lfile	*filep	 	The pointer *filep points to the
 *				 	beginning of a linked list of
 *				 	lfile structures.
 *		globl	*globlp		The pointer to the first
 *				 	globl structure
 *		globl	*gsp		Pointer to the current
 *				 	globl structure
 *		head	*headp		The pointer to the first
 *				 	head structure of a linked list
 *		lbfile	*lbfhead	The pointer to the first
 *					lbfile structure of a linked list
 *		lfile	*linkp		pointer to first lfile structure
 *				 	containing an input REL file
 *				 	specification
 *		int	lop		current line number on page
 *		int	mflag		Map output flag
 *		FILE	*mfp		Map output file handle
 *		int	page		current page number
 *
 *	functions called:
 *		FILE *	afile()		lkmain.c
 *		int	fprintf()	c_library
 *		void	lkexit()	lkmain.c
 *		void	lstarea()	lklist.c
 *		void	newpag()	lklist.c
 *		void	chkbank()	lkbank.c
 *		void	symdef()	lksym.c
 *
 *	side effects:
 *		The map file is created.
 */

void
map(void)
{
	int i;
	struct head *hdp;
	struct lbfile *lbfh;

	if (mflag == 0) return;

	/*
	 * Open Map File
	 */
	mfp = afile(linkp->f_idp, "map", 1);
	if (mfp == NULL) {
		lkexit(ER_FATAL);
	}

	/*
	 * Output Map Bank/Area Lists
	 */
	page = 0;
        lop  = NLPP;
	for (bp = bankp; bp != NULL; bp = bp->b_bp) {
		for (ap = areap; ap != NULL; ap = ap->a_ap) {
			if (ap->a_bp == bp)
				lstarea(ap, bp);
		}
	}

	/*
	 * List Linked Files
	 */
	newpag(mfp);
        fprintf(mfp, "\nFiles Linked                              [ module(s) ]\n\n");
	hdp = headp;
	filep = linkp->f_flp;
	while (filep) {
                if (strlen (filep->f_idp) > 40)
                        fprintf(mfp, "%s\n%40s  [ ", filep->f_idp, "");
                else
                        fprintf(mfp, "%-40.40s  [ ", filep->f_idp);
		i = 0;
		while ((hdp != NULL) && (hdp->h_lfile == filep)) {
			if (i)
				fprintf(mfp, ",\n%44s", "");
			fprintf(mfp, "%-.32s", hdp->m_id);
			hdp = hdp->h_hp;
			i++;
		}
                fprintf(mfp, " ]\n");
		filep = filep->f_flp;
	}
	fprintf(mfp, "\n");
	/*
	 * List Linked Libraries
	 */
	if (lbfhead != NULL) {
                fprintf(mfp, "\nLibraries Linked                          [ object file ]\n\n");
		for (lbfh=lbfhead; lbfh; lbfh=lbfh->next) {
                        if (strlen (lbfh->libspc) > 40)
                                fprintf(mfp, "%s\n%40s  [ %-.32s ]\n",
                                        lbfh->libspc, "", lbfh->relfil);
                        else
                                fprintf(mfp, "%-40.40s  [ %-.32s ]\n",
                                        lbfh->libspc, lbfh->relfil);
		}
		fprintf(mfp, "\n");
	}
	/*
	 * List Base Address Definitions
	 */
	if (basep) {
		newpag(mfp);
		fprintf(mfp, "\nUser Base Address Definitions\n\n");
		bsp = basep;
		while (bsp) {
			fprintf(mfp, "%s\n", bsp->b_strp);
			bsp = bsp->b_base;
		}
	}
	/*
	 * List Global Definitions
	 */
	if (globlp) {
		newpag(mfp);
		fprintf(mfp, "\nUser Global Definitions\n\n");
		gsp = globlp;
		while (gsp) {
			fprintf(mfp, "%s\n", gsp->g_strp);
			gsp = gsp->g_globl;
		}
	}
	fprintf(mfp, "\n\f");
	chkbank(mfp);
	symdef(mfp);
}

/*)Function	int	parse(void)
 *
 *	The function parse() evaluates all command line or file input
 *	linker directives and updates the appropriate variables.
 *
 *	local variables:
 *		int	c		character value
 *		int	sv_type		save type of processing
 *		char	fid[]		file id string
 *
 *	global variables:
 *		char	ctype[]		array of character types, one per
 *				 	ASCII character
 *		lfile	*lfp		pointer to current lfile structure
 *				 	being processed by parse()
 *		lfile	*linkp		pointer to first lfile structure
 *				 	containing an input REL file
 *				 	specification
 *		int	mflag		Map output flag
 *		int	oflag		Output file type flag
 *		int	objflg		Linked file/library output object flag
 *		int	pflag		print linker command file flag
 *		FILE *	stderr		c_library
 *		int	uflag		Relocated listing flag
 *		int	xflag		Map file radix type flag
 *		int	wflag		Wide listing format
 *              int     zflag           Disable symbol case sensitivity
 *
 *	Functions called:
 *		void	addlib()	lklibr.c
 *		void	addpath()	lklibr.c
 *		void	bassav()	lkmain.c
 *		void	doparse()	lkmain.c
 *		int	fprintf()	c_library
 *		void	gblsav()	lkmain.c
 *		void	getfid()	lklex.c
 *		int	get()		lklex.c
 *		int	getnb()		lklex.c
 *		void	lkexit()	lkmain.c
 *		char *	strsto()	lksym.c
 *		int	strlen()	c_library
 *		int	fndidx()	lkmain.c
 *
 *	side effects:
 *		Various linker flags are updated and the linked
 *		structure lfile is created.
 */

int
parse()
{
	int c;
	int sv_type;
        char fid[NINPUT];

	while ((c = getnb()) != 0) {
                /* sdld specific */
                if ( c == ';')
                        return(0);
                /* end sdld specific */
		if ( c == '-') {
			while (ctype[c=get()] & LETTER) {
				switch(c) {

				case 'C':
                                        if (is_sdld() && !(TARGET_IS_Z80 || TARGET_IS_GB)) {
                                                codesav();
						return(0);
					}
                                        // else fall through
				case 'c':
					if (startp->f_type != 0)
						break;
					startp->f_type = F_STD;
					doparse();
					return(0);

				case 'f':
				case 'F':
                                        if (startp->f_type == F_LNK) {
                                                fprintf(stderr, "Nested option -%c ignored\n", c);
						return(0);
					}
					unget(getnb());
                                        if (*ip == 0)
                                                usage(ER_FATAL);
					sv_type = startp->f_type;
					startp->f_idp = strsto(ip);
					startp->f_idx = fndidx(ip);
					startp->f_type = F_LNK;
					doparse();
					if (sv_type == F_STD) {
						cfp = NULL;
						sfp = NULL;
						startp->f_type = F_STD;
						filep = startp;
					}
					return(0);

				case 'I':
                                        if (is_sdld() && !(TARGET_IS_Z80 || TARGET_IS_GB)) {
                                                iramsav();
						return(0);
					}
                                        // else fall through
				case 'i':
					oflag = 1;
					break;

				case 'S':
                                        if (TARGET_IS_8051) {
                                                unget(getnb());
                                                if (ip && *ip)
                                                {
                                                        stacksize = expr(0);
                                                        if (stacksize > 256) stacksize = 256;
                                                        else if (stacksize < 0) stacksize = 0;
                                                }
						return(0);
					}
                                        // else fall through
				case 's':
					oflag = 2;
					break;

				case 't':
				case 'T':
					oflag = 3;
					break;

				case 'o':
				case 'O':
					objflg = 0;
					break;

				case 'v':
				case 'V':
					objflg = 1;
					break;

				case 'M':
                                        /*JCF: memory usage summary output*/
                                        if (is_sdld()) {
                                                sflag = 1;
						break;
					}
                                        // else fall through
				case 'm':
					mflag = 1;
					break;

#if NOICE
				case 'j':
				case 'J':
					jflag = 1;
					break;
#endif

                                case 'r':
                                case 'R':
                                        if (is_sdld() && !(TARGET_IS_Z80 || TARGET_IS_GB))
                                                rflag = 1;
                                        else
                                                goto err;
					break;

				case 'u':
				case 'U':
					uflag = 1;
					break;

				case 'X':
                                        if (is_sdld() && !(TARGET_IS_Z80 || TARGET_IS_GB)) {
                                                xramsav();
						return(0);
					}
                                        // else fall through
				case 'x':
					xflag = 0;
					break;

				case 'q':
				case 'Q':
					xflag = 1;
					break;

				case 'd':
				case 'D':
					xflag = 2;
					break;

				case 'E':
                                        if (TARGET_IS_6808 || TARGET_IS_STM8) {
                                                oflag = 4;
						break;
					}
                                        // else fall through
				case 'e':
					return(1);

				case 'n':
				case 'N':
					pflag = 0;
					break;

				case 'p':
				case 'P':
					pflag = 1;
					break;

				case 'b':
				case 'B':
					bassav();
					return(0);

				case 'g':
				case 'G':
					gblsav();
					return(0);

				case 'k':
				case 'K':
					addpath();
					return(0);

				case 'l':
				case 'L':
					addlib();
					return(0);

				case 'w':
				case 'W':
					wflag = 1;
					break;

#if SDCDB
				case 'Y':
                                        if (TARGET_IS_8051) {
                                                fprintf(stderr,
                                                    "Warning: Treating -Y as -y\n");
					}
                                        // else fall through
				case 'y':
					yflag = 1;
					break;
#endif

				case 'z':
				case 'Z':
					zflag = 1;
					break;

				default:
                                err:
					fprintf(stderr, "?ASlink-Warning-Unkown option -%c ignored\n", c);
					break;
				}
			}
                        /* sdld specific */
                        if ( c == ';')
                                return(0);
                        /* end sdld specific */
		} else
                if (!(ctype[c] & ILL)) {
			if (linkp == NULL) {
				linkp = (struct lfile *)
                                        new (sizeof (struct lfile));
				lfp = linkp;
				lfp->f_type = F_OUT;
			} else {
				lfp->f_flp = (struct lfile *)
						new (sizeof (struct lfile));
				lfp = lfp->f_flp;
				lfp->f_type = F_REL;
			}
                        getfid(fid, c);
                        lfp->f_idp = strsto(fid);
			lfp->f_obj = objflg;
		} else {
			fprintf(stderr, "?ASlink-Error-Invalid input character\n");
			lkexit(ER_FATAL);
		}
	}
	return(0);
}

/*)Function	void	doparse(void)
 *
 *	The function doparse() evaluates all interactive
 *	command line or file input linker directives and
 *	updates the appropriate variables.
 *
 *	local variables:
 *		none
 *
 *	global variables:
 *		FILE *	stdin		standard input
 *		FILE *	stdout		standard output
 *		lfile	*cfp		The pointer *cfp points to the
 *				 	current lfile structure
 *		FILE	*sfp		The file handle sfp points to the
 *				 	currently open file
 *		char	ib[NINPUT]	.rel file text line
 *		char	*ip		pointer into the .rel file
 *		lfile	*filep	 	The pointer *filep points to the
 *				 	beginning of a linked list of
 *				 	lfile structures.
 *		lfile	*startp		asmlnk startup file structure
 *		int	pflag		print linker command file flag
 *
 *	Functions called:
 *		int	fclose()	c_library
 *		int	fprintf()	c_library
 *		int	nxtline()	lklex.c
 *		int	parse()		lkmain.c
 *
 *	side effects:
 *		Various linker flags are updated and the linked
 *		structure lfile may be updated.
 */

void
doparse(void)
{
	cfp = NULL;
	sfp = NULL;
	filep = startp;
	while (1) {
		ip = ib;
		if (nxtline() == 0)
			break;
		if (pflag && cfp->f_type != F_STD)
			fprintf(stdout, "ASlink >> %s\n", ip);
		if (*ip == 0 || parse())
			break;
	}
	if((sfp != NULL) && (sfp != stdin)) {
		fclose(sfp);
	}
	sfp = NULL;
	startp->f_idp = "";
	startp->f_idx = 0;
	startp->f_type = 0;
}

/*)Function	void	bassav(void)  beware sdld changed name
 *
 *	The function bassav() creates a linked structure containing
 *	the base address strings input to the linker.
 *
 *	local variables:
 *		none
 *
 *	global variables:
 *		base	*basep		The pointer to the first
 *				 	base structure
 *		base	*bsp		Pointer to the current
 *				 	base structure
 *		char	*ip		pointer into the REL file
 *				 	text line in ib[]
 *
 *	 functions called:
 *		int	getnb()		lklex.c
 *		void *	new()		lksym.c
 *		int	strlen()	c_library
 *		char *	strcpy()	c_library
 *		void	unget()		lklex.c
 *
 *	side effects:
 *		The basep structure is created.
 */

void
bassav(void) /* beware sdld changed name */
{
	if (basep == NULL) {
		basep = (struct base *)
			new (sizeof (struct base));
		bsp = basep;
	} else {
		bsp->b_base = (struct base *)
				new (sizeof (struct base));
		bsp = bsp->b_base;
	}
	unget(getnb());
	bsp->b_strp = (char *) new (strlen(ip)+1);
	strcpy(bsp->b_strp, ip);
}


/*)Function	void	gblsav()   beware sdld changed name
 *
 *	The function gblsav() creates a linked structure containing
 *	the global variable strings input to the linker.
 *
 *	local variable:
 *		none
 *
 *	global variables:
 *		globl	*globlp		The pointer to the first
 *				 	globl structure
 *		globl	*gsp		Pointer to the current
 *				 	globl structure
 *		char	*ip		pointer into the REL file
 *				 	text line in ib[]
 *
 *	functions called:
 *		int	getnb()		lklex.c
 *		void *	new()		lksym.c
 *		int	strlen()	c_library
 *		char *	strcpy()	c_library
 *		void	unget()		lklex.c
 *
 *	side effects:
 *		The globlp structure is created.
 */

void
gblsav(void)  /* beware sdld changed name */
{
	if (globlp == NULL) {
		globlp = (struct globl *)
			new (sizeof (struct globl));
		gsp = globlp;
	} else {
		gsp->g_globl = (struct globl *)
				new (sizeof (struct globl));
		gsp = gsp->g_globl;
	}
	unget(getnb());
	gsp->g_strp = (char *) new (strlen(ip)+1);
	strcpy(gsp->g_strp, ip);
}


/*)Function	void	setgbl(void)
 *
 *	The function setgbl() scans the global variable lines in the
 *	globlp structure, evaluates the arguments, and sets a variable
 *	to this value.
 *
 *	local variables:
 *		int	v		expression value
 *		char	id[]		base id string
 *		sym *	sp		pointer to a symbol structure
 *
 *	global variables:
 *		char	*ip		pointer into the REL file
 *				 	text line in ib[]
 *		globl	*globlp		The pointer to the first
 *				 	globl structure
 *		globl	*gsp		Pointer to the current
 *				 	globl structure
 *		FILE *	stderr		c_library
 *		int	lkerr		error flag
 *
 *	 functions called:
 *		a_uint	expr()		lkeval.c
 *		int	fprintf()	c_library
 *		void	getid()		lklex.c
 *		int	getnb()		lklex.c
 *		sym *	lkpsym()	lksym.c
 *
 *	side effects:
 *		The value of a variable is set.
 */

void
setgbl(void)
{
	int v;
	struct sym *sp;
	char id[NCPS];

	gsp = globlp;
	while (gsp) {
		ip = gsp->g_strp;
		getid(id, -1);
		if (getnb() == '=') {
			v = (int) expr(0);
			sp = lkpsym(id, 0);
			if (sp == NULL) {
				fprintf(stderr,
				"?ASlink-Error-No definition of symbol %s\n", id);
				lkerr++;
			} else {
				if (sp->s_type & S_DEF) {
					fprintf(stderr,
					"?ASlink-Error-Redefinition of symbol %s\n", id);
					lkerr++;
					sp->s_axp = NULL;
				}
				sp->s_addr = v;
				sp->s_type |= S_DEF;
			}
		} else {
			fprintf(stderr, "?ASlink-Error-No '=' in global expression");
			lkerr++;
		}
		gsp = gsp->g_globl;
	}
}

/*)Function	FILE *	afile(fn, ft, wf)
 *
 *		char *	fn		file specification string
 *		char *	ft		file type string
 *		int	wf		0 ==>> read
 *					1 ==>> write
 *                                      2 ==>> binary write
 *
 *	The function afile() opens a file for reading or writing.
 *		(1)	If the file type specification string ft
 *			is not NULL then a file specification is
 *			constructed with the file path\name in fn
 *			and the extension in ft.
 *		(2)	If the file type specification string ft
 *			is NULL then the file specification is
 *			constructed from fn.  If fn does not have
 *			a file type then the default .rel file
 *			type is appended to the file specification.
 *
 *	afile() returns a file handle for the opened file or aborts
 *	the assembler on an open error.
 *
 *	local variables:
 *		int	c		character value
 *		FILE *	fp		filehandle for opened file
 *		char *	p1		pointer to filespec string fn
 *		char *	p2		pointer to filespec string fb
 *              char *  p3              pointer to filetype string ft
 *
 *	global variables:
 *		char	afspec[]	constructed file specification string
 *		int	lkerr		error flag
 *
 *	functions called:
 *		int	fndidx()	lkmain.c
 *		FILE *	fopen()		c_library
 *		int	fprintf()	c_library
 *
 *	side effects:
 *		File is opened for read or write.
 */

FILE *
afile(char *fn, char *ft, int wf)
{
	char *p1, *p2;
	int c;
	char * frmt;
	FILE *fp;

	if (strlen(fn) > (FILSPC-7)) {
                fprintf(stderr, "?ASlink-Error-<filspc too long> : \"%s\"\n", fn);
		lkerr++;
		return(NULL);
	}

	/*
	 * Skip The Path
	 */
	strcpy(afspec, fn);
	c = fndidx(afspec);

	/*
	 * Skip to File Extension separator
	 */
	p1 = strrchr(&afspec[c], FSEPX);

	/*
	 * Copy File Extension
	 */
        p2 = ft ? ft : "";
        if (*p2 == 0) {
		if (p1 == NULL) {
                        p2 = LKOBJEXT;
		} else {
			p2 = strrchr(&fn[c], FSEPX) + 1;
		}
	}
	if (p1 == NULL) {
		p1 = &afspec[strlen(afspec)];
	}
	*p1++ = FSEPX;
	while ((c = *p2++) != 0) {
		if (p1 < &afspec[FILSPC-1])
			*p1++ = c;
	}
	*p1++ = 0;

	/*
         * Select Read/Write/Binary Write
	 */
        switch(wf & 3) {
	default:
	case 0:	frmt = "r";	break;
	case 1:	frmt = "w";	break;
#ifdef	DECUS
        case 2: frmt = "wn";    break;
#else
        case 2: frmt = "wb";    break;
#endif
	}
        if ((fp = fopen(afspec, frmt)) == NULL && strcmp(ft,"adb") != 0) { /* Do not complain for optional adb files */
                fprintf(stderr, "?ASlink-Error-<cannot %s> : \"%s\"\n", (frmt[0] == 'w')?"create":"open", afspec);
		lkerr++;
	}
	return (fp);
}

/*)Function	int	fndidx(str)
 *
 *		char *	str		file specification string
 *
 *	The function fndidx() scans the file specification string
 *	to find the index to the file name.  If the file
 *	specification contains a 'path' then the index will
 *	be non zero.
 *
 *	fndidx() returns the index value.
 *
 *	local variables:
 *		char *	p1		temporary pointer
 *		char *	p2		temporary pointer
 *
 *	global variables:
 *		none
 *
 *	functions called:
 *		char *	strrchr()	c_library
 *
 *	side effects:
 *		none
 */

int
fndidx(char *str)
{
	char *p1, *p2;

	/*
	 * Skip Path Delimiters
	 */
	p1 = str;
	if ((p2 = strrchr(p1,  ':')) != NULL) { p1 = p2 + 1; }
	if ((p2 = strrchr(p1,  '/')) != NULL) { p1 = p2 + 1; }
	if ((p2 = strrchr(p1, '\\')) != NULL) { p1 = p2 + 1; }

	return((int) (p1 - str));
}

/*)Function	int	fndext(str)
 *
 *		char *	str		file specification string
 *
 *	The function fndext() scans the file specification string
 *	to find the file.ext separater.
 *
 *	fndext() returns the index to FSEPX or the end of the string.
 *
 *	local variables:
 *		char *	p1		temporary pointer
 *		char *	p2		temporary pointer
 *
 *	global variables:
 *		none
 *
 *	functions called:
 *		char *	strrchr()	c_library
 *
 *	side effects:
 *		none
 */

int
fndext(char * str)
{
	char *p1, *p2;

	/*
	 * Find the file separator
	 */
	p1 = str + strlen(str);
	if ((p2 = strrchr(str,  FSEPX)) != NULL) { p1 = p2; }

	return((int) (p1 - str));
}

/* sdld specific */
/*)Function     void    iramsav()
 *
 *      The function iramsav() stores the size of the chip's internal RAM.
 *      This is used after linking to check that variable assignment to this
 *      dataspace didn't overflow into adjoining segments.      Variables in the
 *      DSEG, OSEG, and ISEG are assigned to this dataspace.
 *
 *	local variables:
 *		none
 *
 *	global variables:
 *		char	*ip		pointer into the REL file
 *				 	text line in ib[]
 *              unsigned int            size of chip's internal
 *              iram_size               RAM segment
 *
 *	 functions called:
 *		int	getnb()		lklex.c
 *		void	unget()		lklex.c
 *		a_uint	expr()		lkeval.c
 *
 *	side effects:
 *              The iram_size may be modified.
 */

void
iramsav()
{
  unget(getnb());
  if (ip && *ip)
        iram_size = expr(0);    /* evaluate size expression */
  else
        iram_size = 128;                /* Default is 128 (0x80) bytes */
  if ((iram_size<=0) || (iram_size>256))
        iram_size = 128;                /* Default is 128 (0x80) bytes */
}

/*Similar to iramsav but for xram memory*/
void
xramsav()
{
  unget(getnb());
  if (ip && *ip)
        xram_size = expr(0);    /* evaluate size expression */
  else
        xram_size = rflag?0x1000000:0x10000;
}

/*Similar to iramsav but for code memory*/
void
codesav()
{
  unget(getnb());
  if (ip && *ip)
        code_size = expr(0);    /* evaluate size expression */
  else
        code_size = rflag?0x1000000:0x10000;
}


/*)Function     void    iramcheck()
 *
 *      The function iramcheck() is used at the end of linking to check that
 *      the internal RAM area wasn't overflowed by too many variable
 *      assignments.  Variables in the DSEG, ISEG, and OSEG are assigned to
 *      the chip's internal RAM.
 *
 *	local variables:
 *		none
 *
 *	global variables:
 *              unsigned int            size of chip's internal
 *              iram_size               RAM segment
 *              struct area             linked list of memory
 *              *areap                  areas
 *
 *	 functions called:
 *
 *	side effects:
 */

void
iramcheck()
{
  register unsigned int last_addr;
  register struct area *ap;

  for (ap = areap; ap; ap=ap->a_ap) {
        if ((ap->a_size != 0) &&
                (!strcmp(ap->a_id, "DSEG") ||
                 !strcmp(ap->a_id, "OSEG") ||
                 !strcmp(ap->a_id, "ISEG")
                )
           )
        {
          last_addr = ap->a_addr + ap->a_size - 1;
          if (last_addr >= iram_size)
                fprintf(stderr,
                  "\nWARNING! Segment %s extends past the end\n"
                  "         of internal RAM.  Check map file.\n",
                  ap->a_id);
	}
  }
}
/* end sdld specific */

char *usetxt[] = {
	"Usage: [-Options] [-Option with arg] file",
	"Usage: [-Options] [-Option with arg] outfile file1 [file2 ...]",
        "Startup:",
	"  -p   Echo commands to stdout (default)",
	"  -n   No echo of commands to stdout",
	"Alternates to Command Line Input:",
	"  -c                   ASlink >> prompt input",
        "  -f   file[.lk]       Command File input",
        "Libraries:",
	"  -k   Library path specification, one per -k",
	"  -l   Library file specification, one per -l",
	"Relocation:",
        "  -b   area base address = expression",
        "  -g   global symbol = expression",
	"Map format:",
	"  -m   Map output generated as (out)file[.map]",
	"  -w   Wide listing format for map file",
	"  -x   Hexadecimal (default)",
	"  -d   Decimal",
	"  -q   Octal",
	"Output:",
        "  -i   Intel Hex as (out)file[.ihx]",
        "  -s   Motorola S Record as (out)file[.s19]",
//      "  -t   Tandy CoCo Disk BASIC binary as (out)file[.bi-]",
#if NOICE
	"  -j   NoICE Debug output as (out)file[.noi]",
#endif
#if SDCDB
	"  -y   SDCDB Debug output as (out)file[.cdb]",
#endif
//      "  -o   Linked file/library object output enable (default)",
//      "  -v   Linked file/library object output disable",
	"List:",
	"  -u   Update listing file(s) with link data as file(s)[.rst]",
	"Case Sensitivity:",
	"  -z   Disable Case Sensitivity for Symbols",
	"End:",
	"  -e   or null line terminates input",
	"",
	0
};

char *usetxt_8051[] = {
	"Usage: [-Options] [-Option with arg] file",
	"Usage: [-Options] [-Option with arg] outfile file1 [file2 ...]",
        "Startup:",
	"  -p   Echo commands to stdout (default)",
	"  -n   No echo of commands to stdout",
	"Alternates to Command Line Input:",
	"  -c                   ASlink >> prompt input",
        "  -f   file[.lk]       Command File input",
        "Libraries:",
	"  -k   Library path specification, one per -k",
	"  -l   Library file specification, one per -l",
	"Relocation:",
        "  -b   area base address = expression",
        "  -g   global symbol = expression",
	"Map format:",
	"  -m   Map output generated as (out)file[.map]",
	"  -w   Wide listing format for map file",
	"  -x   Hexadecimal (default)",
	"  -d   Decimal",
	"  -q   Octal",
	"Output:",
        "  -i   Intel Hex as (out)file[.ihx]",
        "  -s   Motorola S Record as (out)file[.s19]",
#if NOICE
	"  -j   NoICE Debug output as (out)file[.noi]",
#endif
#if SDCDB
	"  -y   SDCDB Debug output as (out)file[.cdb]",
#endif
	"List:",
	"  -u   Update listing file(s) with link data as file(s)[.rst]",
	"Case Sensitivity:",
	"  -z   Disable Case Sensitivity for Symbols",
        "Miscellaneous:\n"
        "  -I   [iram-size] Check for internal RAM overflow",
        "  -X   [xram-size] Check for external RAM overflow",
        "  -C   [code-size] Check for code overflow",
        "  -M   Generate memory usage summary file[.mem]",
        "  -S   [stack-size] Allocate space for stack",
	"End:",
	"  -e   or null line terminates input",
	"",
	0
};

char *usetxt_6808[] = {
	"Usage: [-Options] [-Option with arg] file",
	"Usage: [-Options] [-Option with arg] outfile file1 [file2 ...]",
        "Startup:",
	"  -p   Echo commands to stdout (default)",
	"  -n   No echo of commands to stdout",
	"Alternates to Command Line Input:",
	"  -c                   ASlink >> prompt input",
        "  -f   file[.lk]       Command File input",
        "Libraries:",
	"  -k   Library path specification, one per -k",
	"  -l   Library file specification, one per -l",
	"Relocation:",
        "  -b   area base address = expression",
        "  -g   global symbol = expression",
	"Map format:",
	"  -m   Map output generated as (out)file[.map]",
	"  -w   Wide listing format for map file",
	"  -x   Hexadecimal (default)",
	"  -d   Decimal",
	"  -q   Octal",
	"Output:",
        "  -i   Intel Hex as (out)file[.ihx]",
        "  -s   Motorola S Record as (out)file[.s19]",
        "  -E   ELF executable as file[.elf]",
#if NOICE
	"  -j   NoICE Debug output as (out)file[.noi]",
#endif
#if SDCDB
	"  -y   SDCDB Debug output as (out)file[.cdb]",
#endif
	"List:",
	"  -u   Update listing file(s) with link data as file(s)[.rst]",
	"Case Sensitivity:",
	"  -z   Disable Case Sensitivity for Symbols",
        "Miscellaneous:\n"
        "  -I   [iram-size] Check for internal RAM overflow",
        "  -X   [xram-size] Check for external RAM overflow",
        "  -C   [code-size] Check for code overflow",
        "  -M   Generate memory usage summary file[.mem]",
	"End:",
	"  -e   or null line terminates input",
	"",
	0
};

char *usetxt_z80_gb[] = {
	"Usage: [-Options] [-Option with arg] file",
	"Usage: [-Options] [-Option with arg] outfile file1 [file2 ...]",
        "Startup:",
	"  -p   Echo commands to stdout (default)",
	"  -n   No echo of commands to stdout",
	"Alternates to Command Line Input:",
	"  -c                   ASlink >> prompt input",
        "  -f   file[.lk]       Command File input",
        "Libraries:",
	"  -k   Library path specification, one per -k",
	"  -l   Library file specification, one per -l",
	"Relocation:",
        "  -b   area base address = expression",
        "  -g   global symbol = expression",
	"Map format:",
	"  -m   Map output generated as (out)file[.map]",
	"  -w   Wide listing format for map file",
	"  -x   Hexadecimal (default)",
	"  -d   Decimal",
	"  -q   Octal",
	"Output:",
        "  -i   Intel Hex as (out)file[.ihx]",
        "  -s   Motorola S Record as (out)file[.s19]",
#if NOICE
        // can be converted into no$gmb compatible .sym
	"  -j   NoICE Debug output as (out)file[.noi]",
#endif
#if SDCDB
	"  -y   SDCDB Debug output as (out)file[.cdb]",
#endif
	"List:",
	"  -u   Update listing file(s) with link data as file(s)[.rst]",
	"Case Sensitivity:",
	"  -z   Disable Case Sensitivity for Symbols",
	"End:",
	"  -e   or null line terminates input",
	"",
	0
};

/*)Function	void	usage(void)
 *
 *              int     n               exit code
 *
 *	The function usage() outputs to the stderr device the
 *	linker name and version and a list of valid linker options.
 *
 *	local variables:
 *		char **	dp		pointer to an array of
 *					text string pointers.
 *
 *	global variables:
 *		FILE *	stderr		c_library
 *
 *	functions called:
 *		int	fprintf()	c_library
 *
 *	side effects:
 *		none
 */

void
usage(int n)
{
	char	**dp;

        /* sdld specific */
        fprintf(stderr, "\n%s Linker %s\n\n", is_sdld() ? "sdld" : "ASxxxx", VERSION);
        for (dp = TARGET_IS_8051 ? usetxt_8051 : (TARGET_IS_6808 ? usetxt_6808 : ((TARGET_IS_Z80 || TARGET_IS_GB) ? usetxt_z80_gb : usetxt)); *dp; dp++)
		fprintf(stderr, "%s\n", *dp);
        /* end sdld specific */
        lkexit(n);
}

/*)Function     void    copyfile()
 *
 *              FILE    *dest           destination file
 *              FILE    *src            source file
 *
 *              function will copy source file to destination file
 *
 *
 *	functions called:
 *              int     fgetc()                 c_library
 *              int     fputc()                 c_library
 *
 *	side effects:
 *		none
 */
void
copyfile (FILE *dest, FILE *src)
{
        int ch;

        while ((ch = fgetc(src)) != EOF) {
                fputc(ch,dest);
	}
}
